/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"

#define ICV_DIST_SHIFT  16
#define ICV_INIT_DIST0  (INT_MAX >> 2)

static CvStatus
icvInitTopBottom( int* temp, int tempstep, CvSize size, int border ) {
	int i, j;
	for ( i = 0; i < border; i++ ) {
		int* ttop = (int*)(temp + i * tempstep);
		int* tbottom = (int*)(temp + (size.height + border * 2 - i - 1) * tempstep);

		for ( j = 0; j < size.width + border * 2; j++ ) {
			ttop[j] = ICV_INIT_DIST0;
			tbottom[j] = ICV_INIT_DIST0;
		}
	}

	return CV_OK;
}


static CvStatus CV_STDCALL
icvDistanceTransform_3x3_C1R( const uchar* src, int srcstep, int* temp,
							  int step, float* dist, int dststep, CvSize size, const float* metrics ) {
	const int BORDER = 1;
	int i, j;
	const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );
	const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );
	const float scale = 1.f / (1 << ICV_DIST_SHIFT);

	srcstep /= sizeof(src[0]);
	step /= sizeof(temp[0]);
	dststep /= sizeof(dist[0]);

	icvInitTopBottom( temp, step, size, BORDER );

	// forward pass
	for ( i = 0; i < size.height; i++ ) {
		const uchar* s = src + i * srcstep;
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;

		for ( j = 0; j < BORDER; j++ ) {
			tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;
		}

		for ( j = 0; j < size.width; j++ ) {
			if ( !s[j] ) {
				tmp[j] = 0;
			} else {
				int t0 = tmp[j-step-1] + DIAG_DIST;
				int t = tmp[j-step] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step+1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-1] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				tmp[j] = t0;
			}
		}
	}

	// backward pass
	for ( i = size.height - 1; i >= 0; i-- ) {
		float* d = (float*)(dist + i * dststep);
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;

		for ( j = size.width - 1; j >= 0; j-- ) {
			int t0 = tmp[j];
			if ( t0 > HV_DIST ) {
				int t = tmp[j+step+1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step-1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+1] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				tmp[j] = t0;
			}
			d[j] = (float)(t0 * scale);
		}
	}

	return CV_OK;
}


static CvStatus CV_STDCALL
icvDistanceTransform_5x5_C1R( const uchar* src, int srcstep, int* temp,
							  int step, float* dist, int dststep, CvSize size, const float* metrics ) {
	const int BORDER = 2;
	int i, j;
	const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );
	const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );
	const int LONG_DIST = CV_FLT_TO_FIX( metrics[2], ICV_DIST_SHIFT );
	const float scale = 1.f / (1 << ICV_DIST_SHIFT);

	srcstep /= sizeof(src[0]);
	step /= sizeof(temp[0]);
	dststep /= sizeof(dist[0]);

	icvInitTopBottom( temp, step, size, BORDER );

	// forward pass
	for ( i = 0; i < size.height; i++ ) {
		const uchar* s = src + i * srcstep;
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;

		for ( j = 0; j < BORDER; j++ ) {
			tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;
		}

		for ( j = 0; j < size.width; j++ ) {
			if ( !s[j] ) {
				tmp[j] = 0;
			} else {
				int t0 = tmp[j-step*2-1] + LONG_DIST;
				int t = tmp[j-step*2+1] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step-2] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step-1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step+1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-step+2] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j-1] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				tmp[j] = t0;
			}
		}
	}

	// backward pass
	for ( i = size.height - 1; i >= 0; i-- ) {
		float* d = (float*)(dist + i * dststep);
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;

		for ( j = size.width - 1; j >= 0; j-- ) {
			int t0 = tmp[j];
			if ( t0 > HV_DIST ) {
				int t = tmp[j+step*2+1] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step*2-1] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step+2] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step+1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step-1] + DIAG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+step-2] + LONG_DIST;
				if ( t0 > t ) { t0 = t; }
				t = tmp[j+1] + HV_DIST;
				if ( t0 > t ) { t0 = t; }
				tmp[j] = t0;
			}
			d[j] = (float)(t0 * scale);
		}
	}

	return CV_OK;
}


static CvStatus CV_STDCALL
icvDistanceTransformEx_5x5_C1R( const uchar* src, int srcstep, int* temp,
								int step, float* dist, int dststep, int* labels, int lstep,
								CvSize size, const float* metrics ) {
	const int BORDER = 2;

	int i, j;
	const int HV_DIST = CV_FLT_TO_FIX( metrics[0], ICV_DIST_SHIFT );
	const int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], ICV_DIST_SHIFT );
	const int LONG_DIST = CV_FLT_TO_FIX( metrics[2], ICV_DIST_SHIFT );
	const float scale = 1.f / (1 << ICV_DIST_SHIFT);

	srcstep /= sizeof(src[0]);
	step /= sizeof(temp[0]);
	dststep /= sizeof(dist[0]);
	lstep /= sizeof(labels[0]);

	icvInitTopBottom( temp, step, size, BORDER );

	// forward pass
	for ( i = 0; i < size.height; i++ ) {
		const uchar* s = src + i * srcstep;
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;
		int* lls = (int*)(labels + i * lstep);

		for ( j = 0; j < BORDER; j++ ) {
			tmp[-j-1] = tmp[size.width + j] = ICV_INIT_DIST0;
		}

		for ( j = 0; j < size.width; j++ ) {
			if ( !s[j] ) {
				tmp[j] = 0;
				//assert( lls[j] != 0 );
			} else {
				int t0 = ICV_INIT_DIST0, t;
				int l0 = 0;

				t = tmp[j-step*2-1] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep*2-1];
				}
				t = tmp[j-step*2+1] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep*2+1];
				}
				t = tmp[j-step-2] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep-2];
				}
				t = tmp[j-step-1] + DIAG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep-1];
				}
				t = tmp[j-step] + HV_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep];
				}
				t = tmp[j-step+1] + DIAG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep+1];
				}
				t = tmp[j-step+2] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-lstep+2];
				}
				t = tmp[j-1] + HV_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j-1];
				}

				tmp[j] = t0;
				lls[j] = l0;
			}
		}
	}

	// backward pass
	for ( i = size.height - 1; i >= 0; i-- ) {
		float* d = (float*)(dist + i * dststep);
		int* tmp = (int*)(temp + (i + BORDER) * step) + BORDER;
		int* lls = (int*)(labels + i * lstep);

		for ( j = size.width - 1; j >= 0; j-- ) {
			int t0 = tmp[j];
			int l0 = lls[j];
			if ( t0 > HV_DIST ) {
				int t = tmp[j+step*2+1] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep*2+1];
				}
				t = tmp[j+step*2-1] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep*2-1];
				}
				t = tmp[j+step+2] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep+2];
				}
				t = tmp[j+step+1] + DIAG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep+1];
				}
				t = tmp[j+step] + HV_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep];
				}
				t = tmp[j+step-1] + DIAG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep-1];
				}
				t = tmp[j+step-2] + LONG_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+lstep-2];
				}
				t = tmp[j+1] + HV_DIST;
				if ( t0 > t ) {
					t0 = t;
					l0 = lls[j+1];
				}
				tmp[j] = t0;
				lls[j] = l0;
			}
			d[j] = (float)(t0 * scale);
		}
	}

	return CV_OK;
}


static CvStatus
icvGetDistanceTransformMask( int maskType, float* metrics ) {
	if ( !metrics ) {
		return CV_NULLPTR_ERR;
	}

	switch (maskType) {
	case 30:
		metrics[0] = 1.0f;
		metrics[1] = 1.0f;
		break;

	case 31:
		metrics[0] = 1.0f;
		metrics[1] = 2.0f;
		break;

	case 32:
		metrics[0] = 0.955f;
		metrics[1] = 1.3693f;
		break;

	case 50:
		metrics[0] = 1.0f;
		metrics[1] = 1.0f;
		metrics[2] = 2.0f;
		break;

	case 51:
		metrics[0] = 1.0f;
		metrics[1] = 2.0f;
		metrics[2] = 3.0f;
		break;

	case 52:
		metrics[0] = 1.0f;
		metrics[1] = 1.4f;
		metrics[2] = 2.1969f;
		break;
	default:
		return CV_BADRANGE_ERR;
	}

	return CV_OK;
}

namespace cv {

struct DTColumnInvoker {
	DTColumnInvoker( const CvMat* _src, CvMat* _dst, const int* _sat_tab, const float* _sqr_tab) {
		src = _src;
		dst = _dst;
		sat_tab = _sat_tab + src->rows * 2 + 1;
		sqr_tab = _sqr_tab;
	}

	void operator()( const BlockedRange& range ) const {
		int i, i1 = range.begin(), i2 = range.end();
		int m = src->rows;
		size_t sstep = src->step, dstep = dst->step / sizeof(float);
		AutoBuffer<int> _d(m);
		int* d = _d;

		for ( i = i1; i < i2; i++ ) {
			const uchar* sptr = src->data.ptr + i + (m - 1) * sstep;
			float* dptr = dst->data.fl + i;
			int j, dist = m - 1;

			for ( j = m - 1; j >= 0; j--, sptr -= sstep ) {
				dist = (dist + 1) & (sptr[0] == 0 ? 0 : -1);
				d[j] = dist;
			}

			dist = m - 1;
			for ( j = 0; j < m; j++, dptr += dstep ) {
				dist = dist + 1 - sat_tab[dist - d[j]];
				d[j] = dist;
				dptr[0] = sqr_tab[dist];
			}
		}
	}

	const CvMat* src;
	CvMat* dst;
	const int* sat_tab;
	const float* sqr_tab;
};


struct DTRowInvoker {
	DTRowInvoker( CvMat* _dst, const float* _sqr_tab, const float* _inv_tab ) {
		dst = _dst;
		sqr_tab = _sqr_tab;
		inv_tab = _inv_tab;
	}

	void operator()( const BlockedRange& range ) const {
		const float inf = 1e6f;
		int i, i1 = range.begin(), i2 = range.end();
		int n = dst->cols;
		AutoBuffer<uchar> _buf((n + 2) * 2 * sizeof(float) + (n + 2)*sizeof(int));
		float* f = (float*)(uchar*)_buf;
		float* z = f + n;
		int* v = alignPtr((int*)(z + n + 1), sizeof(int));

		for ( i = i1; i < i2; i++ ) {
			float* d = (float*)(dst->data.ptr + i * dst->step);
			int p, q, k;

			v[0] = 0;
			z[0] = -inf;
			z[1] = inf;
			f[0] = d[0];

			for ( q = 1, k = 0; q < n; q++ ) {
				float fq = d[q];
				f[q] = fq;

				for (;; k--) {
					p = v[k];
					float s = (fq + sqr_tab[q] - d[p] - sqr_tab[p]) * inv_tab[q - p];
					if ( s > z[k] ) {
						k++;
						v[k] = q;
						z[k] = s;
						z[k+1] = inf;
						break;
					}
				}
			}

			for ( q = 0, k = 0; q < n; q++ ) {
				while ( z[k+1] < q ) {
					k++;
				}
				p = v[k];
				d[q] = std::sqrt(sqr_tab[std::abs(q - p)] + f[p]);
			}
		}
	}

	CvMat* dst;
	const float* sqr_tab;
	const float* inv_tab;
};

}

static void
icvTrueDistTrans( const CvMat* src, CvMat* dst ) {
	const float inf = 1e6f;

	if ( !CV_ARE_SIZES_EQ( src, dst )) {
		CV_Error( CV_StsUnmatchedSizes, "" );
	}

	if ( CV_MAT_TYPE(src->type) != CV_8UC1 ||
			CV_MAT_TYPE(dst->type) != CV_32FC1 )
		CV_Error( CV_StsUnsupportedFormat,
				  "The input image must have 8uC1 type and the output one must have 32fC1 type" );

	int i, m = src->rows, n = src->cols;

	cv::AutoBuffer<uchar> _buf(std::max(m * 2 * sizeof(float) + (m * 3 + 1)*sizeof(int), n * 2 * sizeof(float)));
	// stage 1: compute 1d distance transform of each column
	float* sqr_tab = (float*)(uchar*)_buf;
	int* sat_tab = cv::alignPtr((int*)(sqr_tab + m * 2), sizeof(int));
	int shift = m * 2;

	for ( i = 0; i < m; i++ ) {
		sqr_tab[i] = (float)(i * i);
	}
	for ( i = m; i < m * 2; i++ ) {
		sqr_tab[i] = inf;
	}
	for ( i = 0; i < shift; i++ ) {
		sat_tab[i] = 0;
	}
	for ( ; i <= m * 3; i++ ) {
		sat_tab[i] = i - shift;
	}

	cv::parallel_for(cv::BlockedRange(0, n), cv::DTColumnInvoker(src, dst, sat_tab, sqr_tab));

	// stage 2: compute modified distance transform for each row
	float* inv_tab = sqr_tab + n;

	inv_tab[0] = sqr_tab[0] = 0.f;
	for ( i = 1; i < n; i++ ) {
		inv_tab[i] = (float)(0.5 / i);
		sqr_tab[i] = (float)(i * i);
	}

	cv::parallel_for(cv::BlockedRange(0, m), cv::DTRowInvoker(dst, sqr_tab, inv_tab));
}


/*********************************** IPP functions *********************************/

typedef CvStatus (CV_STDCALL* CvIPPDistTransFunc)( const uchar* src, int srcstep,
		void* dst, int dststep,
		CvSize size, const void* metrics );

typedef CvStatus (CV_STDCALL* CvIPPDistTransFunc2)( uchar* src, int srcstep,
		CvSize size, const int* metrics );

/***********************************************************************************/

typedef CvStatus (CV_STDCALL* CvDistTransFunc)( const uchar* src, int srcstep,
		int* temp, int tempstep,
		float* dst, int dststep,
		CvSize size, const float* metrics );


/****************************************************************************************\
 Non-inplace and Inplace 8u->8u Distance Transform for CityBlock (a.k.a. L1) metric
 (C) 2006 by Jay Stavinzky.
\****************************************************************************************/

//BEGIN ATS ADDITION
/* 8-bit grayscale distance transform function */
static void
icvDistanceATS_L1_8u( const CvMat* src, CvMat* dst ) {
	int width = src->cols, height = src->rows;

	int a;
	uchar lut[256];
	int x, y;

	const uchar* sbase = src->data.ptr;
	uchar* dbase = dst->data.ptr;
	int srcstep = src->step;
	int dststep = dst->step;

	CV_Assert( CV_IS_MASK_ARR( src ) && CV_MAT_TYPE( dst->type ) == CV_8UC1 );
	CV_Assert( CV_ARE_SIZES_EQ( src, dst ));

	////////////////////// forward scan ////////////////////////
	for ( x = 0; x < 256; x++ ) {
		lut[x] = CV_CAST_8U(x + 1);
	}

	//init first pixel to max (we're going to be skipping it)
	dbase[0] = (uchar)(sbase[0] == 0 ? 0 : 255);

	//first row (scan west only, skip first pixel)
	for ( x = 1; x < width; x++ ) {
		dbase[x] = (uchar)(sbase[x] == 0 ? 0 : lut[dbase[x-1]]);
	}

	for ( y = 1; y < height; y++ ) {
		sbase += srcstep;
		dbase += dststep;

		//for left edge, scan north only
		a = sbase[0] == 0 ? 0 : lut[dbase[-dststep]];
		dbase[0] = (uchar)a;

		for ( x = 1; x < width; x++ ) {
			a = sbase[x] == 0 ? 0 : lut[MIN(a, dbase[x - dststep])];
			dbase[x] = (uchar)a;
		}
	}

	////////////////////// backward scan ///////////////////////

	a = dbase[width-1];

	// do last row east pixel scan here (skip bottom right pixel)
	for ( x = width - 2; x >= 0; x-- ) {
		a = lut[a];
		dbase[x] = (uchar)(CV_CALC_MIN_8U(a, dbase[x]));
	}

	// right edge is the only error case
	for ( y = height - 2; y >= 0; y-- ) {
		dbase -= dststep;

		// do right edge
		a = lut[dbase[width-1+dststep]];
		dbase[width-1] = (uchar)(MIN(a, dbase[width-1]));

		for ( x = width - 2; x >= 0; x-- ) {
			int b = dbase[x+dststep];
			a = lut[MIN(a, b)];
			dbase[x] = (uchar)(MIN(a, dbase[x]));
		}
	}
}
//END ATS ADDITION


/* Wrapper function for distance transform group */
CV_IMPL void
cvDistTransform( const void* srcarr, void* dstarr,
				 int distType, int maskSize,
				 const float* mask,
				 void* labelsarr ) {
	cv::Ptr<CvMat> temp;
	cv::Ptr<CvMat> src_copy;
	cv::Ptr<CvMemStorage> st;

	float _mask[5] = {0};
	CvMat srcstub, *src = (CvMat*)srcarr;
	CvMat dststub, *dst = (CvMat*)dstarr;
	CvMat lstub, *labels = (CvMat*)labelsarr;
	CvSize size;
	//CvIPPDistTransFunc ipp_func = 0;
	//CvIPPDistTransFunc2 ipp_inp_func = 0;

	src = cvGetMat( src, &srcstub );
	dst = cvGetMat( dst, &dststub );

	if ( !CV_IS_MASK_ARR( src ) || (CV_MAT_TYPE( dst->type ) != CV_32FC1 &&
									(CV_MAT_TYPE(dst->type) != CV_8UC1 || distType != CV_DIST_L1 || labels)) )
		CV_Error( CV_StsUnsupportedFormat,
				  "source image must be 8uC1 and the distance map must be 32fC1 "
				  "(or 8uC1 in case of simple L1 distance transform)" );

	if ( !CV_ARE_SIZES_EQ( src, dst )) {
		CV_Error( CV_StsUnmatchedSizes, "the source and the destination images must be of the same size" );
	}

	if ( maskSize != CV_DIST_MASK_3 && maskSize != CV_DIST_MASK_5 && maskSize != CV_DIST_MASK_PRECISE ) {
		CV_Error( CV_StsBadSize, "Mask size should be 3 or 5 or 0 (presize)" );
	}

	if ( distType == CV_DIST_C || distType == CV_DIST_L1 ) {
		maskSize = !labels ? CV_DIST_MASK_3 : CV_DIST_MASK_5;
	} else if ( distType == CV_DIST_L2 && labels ) {
		maskSize = CV_DIST_MASK_5;
	}

	if ( maskSize == CV_DIST_MASK_PRECISE ) {
		icvTrueDistTrans( src, dst );
		return;
	}

	if ( labels ) {
		labels = cvGetMat( labels, &lstub );
		if ( CV_MAT_TYPE( labels->type ) != CV_32SC1 ) {
			CV_Error( CV_StsUnsupportedFormat, "the output array of labels must be 32sC1" );
		}

		if ( !CV_ARE_SIZES_EQ( labels, dst )) {
			CV_Error( CV_StsUnmatchedSizes, "the array of labels has a different size" );
		}

		if ( maskSize == CV_DIST_MASK_3 )
			CV_Error( CV_StsNotImplemented,
					  "3x3 mask can not be used for \"labeled\" distance transform. Use 5x5 mask" );
	}

	if ( distType == CV_DIST_C || distType == CV_DIST_L1 || distType == CV_DIST_L2 ) {
		icvGetDistanceTransformMask( (distType == CV_DIST_C ? 0 :
									  distType == CV_DIST_L1 ? 1 : 2) + maskSize * 10, _mask );
	} else if ( distType == CV_DIST_USER ) {
		if ( !mask ) {
			CV_Error( CV_StsNullPtr, "" );
		}

		memcpy( _mask, mask, (maskSize / 2 + 1)*sizeof(float));
	}

	/*if( !labels )
	{
	    if( CV_MAT_TYPE(dst->type) == CV_32FC1 )
	        ipp_func = (CvIPPDistTransFunc)(maskSize == CV_DIST_MASK_3 ?
	            icvDistanceTransform_3x3_8u32f_C1R_p : icvDistanceTransform_5x5_8u32f_C1R_p);
	    else if( src->data.ptr != dst->data.ptr )
	        ipp_func = (CvIPPDistTransFunc)icvDistanceTransform_3x3_8u_C1R_p;
	    else
	        ipp_inp_func = icvDistanceTransform_3x3_8u_C1IR_p;
	}*/

	size = cvGetMatSize(src);

	/*if( (ipp_func || ipp_inp_func) && src->cols >= 4 && src->rows >= 2 )
	{
	    int _imask[3];
	    _imask[0] = cvRound(_mask[0]);
	    _imask[1] = cvRound(_mask[1]);
	    _imask[2] = cvRound(_mask[2]);

	    if( ipp_func )
	    {
	        IPPI_CALL( ipp_func( src->data.ptr, src->step,
	                dst->data.fl, dst->step, size,
	                CV_MAT_TYPE(dst->type) == CV_8UC1 ?
	                (void*)_imask : (void*)_mask ));
	    }
	    else
	    {
	        IPPI_CALL( ipp_inp_func( src->data.ptr, src->step, size, _imask ));
	    }
	}
	else*/ if ( CV_MAT_TYPE(dst->type) == CV_8UC1 ) {
		icvDistanceATS_L1_8u( src, dst );
	} else {
		int border = maskSize == CV_DIST_MASK_3 ? 1 : 2;
		temp = cvCreateMat( size.height + border * 2, size.width + border * 2, CV_32SC1 );

		if ( !labels ) {
			CvDistTransFunc func = maskSize == CV_DIST_MASK_3 ?
								   icvDistanceTransform_3x3_C1R :
								   icvDistanceTransform_5x5_C1R;

			func( src->data.ptr, src->step, temp->data.i, temp->step,
				  dst->data.fl, dst->step, size, _mask );
		} else {
			CvSeq* contours = 0;
			CvPoint top_left = {0, 0}, bottom_right = {size.width - 1, size.height - 1};
			int label;

			st = cvCreateMemStorage();
			src_copy = cvCreateMat( size.height, size.width, src->type );
			cvCmpS( src, 0, src_copy, CV_CMP_EQ );
			cvFindContours( src_copy, st, &contours, sizeof(CvContour),
							CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
			cvZero( labels );
			for ( label = 1; contours != 0; contours = contours->h_next, label++ ) {
				CvScalar area_color = cvScalarAll(label);
				cvDrawContours( labels, contours, area_color, area_color, -255, -1, 8 );
			}

			cvCopy( src, src_copy );
			cvRectangle( src_copy, top_left, bottom_right, cvScalarAll(255), 1, 8 );

			icvDistanceTransformEx_5x5_C1R( src_copy->data.ptr, src_copy->step, temp->data.i, temp->step,
											dst->data.fl, dst->step, labels->data.i, labels->step, size, _mask );
		}
	}
}

void cv::distanceTransform( const Mat& src, Mat& dst, Mat& labels,
							int distanceType, int maskSize ) {
	dst.create(src.size(), CV_32F);
	labels.create(src.size(), CV_32S);
	CvMat _src = src, _dst = dst, _labels = labels;
	cvDistTransform(&_src, &_dst, distanceType, maskSize, 0, &_labels);
}

void cv::distanceTransform( const Mat& src, Mat& dst,
							int distanceType, int maskSize ) {
	dst.create(src.size(), CV_32F);
	CvMat _src = src, _dst = dst;
	cvDistTransform(&_src, &_dst, distanceType, maskSize, 0, 0);
}

/* End of file. */
